package rhplus.servico;

import java.util.Date;
import java.util.Hashtable;
import java.util.LinkedList;
import java.util.List;
import javax.jdo.PersistenceManager;
import javax.jdo.annotations.IdGeneratorStrategy;
import javax.jdo.annotations.PersistenceCapable;
import javax.jdo.annotations.Persistent;
import javax.jdo.annotations.PrimaryKey;
import rhplus.acessoBD.PMF;


@PersistenceCapable
public class Servico {


    @PrimaryKey
    @Persistent(valueStrategy = IdGeneratorStrategy.IDENTITY)
    private Long id_servico;
    @Persistent
    private Long id_colaborador;
    @Persistent
    private Long id_utente;
    @Persistent
    private Long id_pagamento;
    @Persistent
    private Double preco;
    @Persistent
    private Double percentagem;
    @Persistent
    private Date data;
    @Persistent
    private String sintoma;
    @Persistent
    private String diagnostico;
    @Persistent
    private String estado;
    @Persistent
    private String observacao_publica;
    @Persistent
    private String observacao_privada;
    @Persistent
    private Long id_servico_generico;
    @Persistent
    private Long id_hospital;
    public static final String ESTADO_CANCELADO = "cancelado";
    public static final String ESTADO_CONCLUIDO_POR_COMPARENCIA = "concluido_por_comparencia";
    public static final String ESTADO_CONCLUIDO_POR_FALTA = "concluido_por_falta";
    public static final String ESTADO_ACTIVO = "activo";

    public Servico(final Long id_colaborador, final Long id_utente, final Long id_pagamento, final Double preco,
            final Double percentagem, final Date data, final String sintoma, final String diagnostico, final String estado,
            final String observacao_publica, final String observacao_privada, final Long servico_generico, final Long id_hospital) {


        this.id_colaborador = id_colaborador;
        this.id_utente = id_utente;
        this.id_pagamento = id_pagamento;
        this.preco = preco;
        this.percentagem = percentagem;
        this.data = data;
        this.sintoma = sintoma;
        this.diagnostico = diagnostico;
        this.estado = estado;
        this.observacao_publica = observacao_publica;
        this.observacao_privada = observacao_privada;
        this.id_servico_generico = servico_generico;
        this.id_hospital = id_hospital;

    }

    public Long getIdServico() {
        return id_servico;
    }

    public Long getColaborador() {
        return id_colaborador;
    }

//    public void setColaborador(final Colaborador colaborador) {
//        this.colaborador = colaborador;
//    }

    public Long getUtente() {
    return id_utente;
    }

//    public void setUtente(final Utente utente) {
//    this.utente = utente;
//    }
    public Long getIdPagamento() {
        return id_pagamento;
    }


    public void setIdPagamento(final Long id_pagamento) {
        this.id_pagamento = id_pagamento;
    }

    public double getPreco() {
        return preco;
    }

    public void setPreco(final double preco) {
        this.preco = preco;
    }

    public double getPercentagem() {
        return percentagem;
    }

    public void setPercentagem(final double percentagem) {
        this.percentagem = percentagem;
    }

    public Date getData() {
        return data;
    }

    public void setData(final Date data) {
        this.data = data;
    }

    public String getSintoma() {
        return sintoma;
    }

    public void setSintoma(final String sintoma) {
        this.sintoma = sintoma;
    }

    public String getDiagnostico() {
        return diagnostico;
    }

    public void setDiagnostico(final String diagnostico) {
        this.diagnostico = diagnostico;
    }

    public String getEstado() {
        return estado;
    }

    public void setEstado(final String estado) {
        this.estado = estado;
    }

    public String getObservacaoPublica() {
        return observacao_publica;
    }

    public void setObservacaoPublica(final String observacao_publica) {
        this.observacao_publica = observacao_publica;
    }

    public String getObservacaoPrivada() {
        return observacao_privada;
    }

    public void setObservacaoPrivada(final String observacao_privada) {
        this.observacao_privada = observacao_privada;
    }

    public Long getServicoGenerico() {
        return id_servico_generico;
    }

    public Long getIdHospital() {
        return id_hospital;
    }

    public void cancela() {
        this.estado = Servico.ESTADO_CANCELADO;
    }

    public void concluiPorComparencia() {
        this.estado = Servico.ESTADO_CONCLUIDO_POR_COMPARENCIA;
    }

    public void concluiPorFalta() {
        this.estado = Servico.ESTADO_CONCLUIDO_POR_FALTA;
    }

    public static void insere(final Servico servico_prestado) throws Exception {

        PersistenceManager pm = PMF.get().getPersistenceManager();

        try {
            pm.makePersistent(servico_prestado);
        } finally {
            pm.close();
        }


    }

    // Insere o exame na tabela servicoprestado
    public static void insereServicoExame(final Servico dados_do_servico_prestado) throws ClassNotFoundException,
            InstantiationException, IllegalAccessException {

        PersistenceManager pm = PMF.get().getPersistenceManager();

        try {
            pm.makePersistent(dados_do_servico_prestado);
        } finally {
            pm.close();
        }

    }

    public static void insereConsultaExame(final Servico dados_do_servico_prestado) throws ClassNotFoundException,
            InstantiationException, IllegalAccessException {

        PersistenceManager pm = PMF.get().getPersistenceManager();

        try {
            pm.makePersistent(dados_do_servico_prestado);
        } finally {
            pm.close();
        }


    }

    public static void insereInternamento(final Servico dados_para_internamento) throws ClassNotFoundException,
            InstantiationException, IllegalAccessException {

        PersistenceManager pm = PMF.get().getPersistenceManager();

        try {
            pm.makePersistent(dados_para_internamento);
        } finally {
            pm.close();
        }

    }

    public static void altera(Servico dados_do_servico_prestado) throws ClassNotFoundException,
            InstantiationException, IllegalAccessException {

        PersistenceManager pm = PMF.get().getPersistenceManager();


//        Colaborador colaborador = dados_do_servico_prestado.getColaborador();
//        Utente utente = dados_do_servico_prestado.getUtente();
        Long id_pagamento = dados_do_servico_prestado.getIdPagamento();
        double preco = dados_do_servico_prestado.getPreco();
        double percentagem = dados_do_servico_prestado.getPercentagem();
        Date data = dados_do_servico_prestado.getData();
        String sintoma = dados_do_servico_prestado.getSintoma();
        String diagnostico = dados_do_servico_prestado.getDiagnostico();
        String estado = dados_do_servico_prestado.getEstado();
        String observacao_publica = dados_do_servico_prestado.getObservacaoPublica();
        String observacao_privada = dados_do_servico_prestado.getObservacaoPrivada();
        Long servico_generico = dados_do_servico_prestado.getServicoGenerico();
        Long id_hospital = dados_do_servico_prestado.getIdHospital();


        try {
            pm.currentTransaction().begin();

            dados_do_servico_prestado = pm.getObjectById(Servico.class, dados_do_servico_prestado.getIdServico());

//            dados_do_servico_prestado.setColaborador(colaborador);
//            dados_do_servico_prestado.setUtente(utente);
            dados_do_servico_prestado.setIdPagamento(id_pagamento);
            dados_do_servico_prestado.setPreco(preco);
            dados_do_servico_prestado.setPercentagem(percentagem);
            dados_do_servico_prestado.setData(data);
            dados_do_servico_prestado.setSintoma(sintoma);
            dados_do_servico_prestado.setDiagnostico(diagnostico);
            dados_do_servico_prestado.setEstado(estado);
            dados_do_servico_prestado.setObservacaoPublica(observacao_publica);
            dados_do_servico_prestado.setObservacaoPrivada(observacao_privada);
            //  dados_do_servico_prestado.getServicoGenerico();
            //   dados_do_servico_prestado.getIdHospital();
            // Falta meter setServicoGenerico e serIdHospital????????
            //
            pm.makePersistent(dados_do_servico_prestado);
            pm.currentTransaction().commit();
        } catch (Exception ex) {
            pm.currentTransaction().rollback();
            throw new RuntimeException(ex);
        } finally {
            pm.close();
        }

    }

    public static void alteraExame(final Servico dados_do_exame) throws ClassNotFoundException,
            InstantiationException, IllegalAccessException {
        /*  AcessoBD acesso_bd = new AcessoBD();

        acesso_bd.carregaDriverEAbreLigacao();
        String qryName = new String("alterar_exame");
        acesso_bd.executaUpdate(qryName, dados_do_exame);
        acesso_bd.fechaLigacao();

     
         *
         */

    }

    public static void remove(final Long id_servico_prestado) throws ClassNotFoundException, InstantiationException,
            IllegalAccessException {

        PersistenceManager pm = PMF.get().getPersistenceManager();
        try {
            pm.currentTransaction().begin();

            // We don't have a reference to the selected Product.
            // So we have to look it up first,
            Servico servico = pm.getObjectById(Servico.class, id_servico_prestado);
            pm.deletePersistent(servico);

            pm.currentTransaction().commit();
        } catch (Exception ex) {
            pm.currentTransaction().rollback();
            throw new RuntimeException(ex);
        } finally {
            pm.close();
        }

    }

    public static void removePorIdDoUtente(final Long id_utente) throws ClassNotFoundException, InstantiationException,
            IllegalAccessException {

        PersistenceManager pm = PMF.get().getPersistenceManager();
        try {
            pm.currentTransaction().begin();

            Servico servico = pm.getObjectById(Servico.class, id_utente);
            pm.deletePersistent(servico);

            pm.currentTransaction().commit();
        } catch (Exception ex) {
            pm.currentTransaction().rollback();
            throw new RuntimeException(ex);
        } finally {
            pm.close();
        }

    }

    public static Servico devolve(final Long id_servico_prestado) throws ClassNotFoundException, InstantiationException,
            IllegalAccessException {

        PersistenceManager pm = PMF.get().getPersistenceManager();

        String query = "select from " + Servico.class.getName()
                + " where id_servico_prestado == " + id_servico_prestado;

        Servico servico = (Servico) pm.newQuery(query).execute();

        return servico;


    }

    public static List<Servico> devolveTodosOsActivos() throws ClassNotFoundException, InstantiationException,
            IllegalAccessException {

        PersistenceManager pm = PMF.get().getPersistenceManager();

        String query = "select from " + Servico.class.getName();

        List<Servico> lista_de_todos_activos = (List<Servico>) pm.newQuery(query).execute();

        return lista_de_todos_activos;


    }

    public static void portarServicoParaOutroHospital(final Hashtable<String, Object> dados) throws ClassNotFoundException,
            InstantiationException, IllegalAccessException {

        /*AcessoBD acesso_bd = new AcessoBD();
        acesso_bd.carregaDriverEAbreLigacao();
        String qryName = new String("portar_servico_para_outro_hospital");
        acesso_bd.executaUpdate(qryName, dados);
        acesso_bd.fechaLigacao();*/
    }

    public static LinkedList<Servico> devolveTodosOsActivosDoUtente(final Long id_utente) throws Exception {
        PersistenceManager pm = PMF.get().getPersistenceManager();

        //SELECT * FROM servicoprestado WHERE estado='activo' AND id_utente=var_id_utente ORDER BY data ASC
        String query = "select from " + Servico.class.getName()
                + " where id_utente == " + id_utente + " && estado == 'activo'";

        List<Servico> lista_de_todos_activos_utente = (List<Servico>) pm.newQuery(query).execute();

        LinkedList<Servico> activos_utente = new LinkedList<Servico>();
        for (Servico s : lista_de_todos_activos_utente) {
            activos_utente.add(s);
        }
        return activos_utente;
    }

    public static LinkedList<Servico> devolveTodosOsActivosDoColaborador(final Long id_colaborador) throws Exception {

        PersistenceManager pm = PMF.get().getPersistenceManager();

        String query = "select from " + Servico.class.getName()+ " where id_colaborador == " + id_colaborador;

        List<Servico> lista_de_activo_colaborador = (List<Servico>) pm.newQuery(query).execute();
        
        LinkedList<Servico> lista = new LinkedList<Servico>();

        for(Servico s : lista_de_activo_colaborador){
            lista.add(s);
        }
        return lista;
    }

    public static LinkedList<Servico> devolveTodosOsExames(final Long id_consulta) throws ClassNotFoundException,
            InstantiationException, IllegalAccessException {

        PersistenceManager pm = PMF.get().getPersistenceManager();

        String query = "select from " + Servico.class.getName()
                + " where id_consulta == " + id_consulta;

        LinkedList<Servico> lista_de_exames = (LinkedList<Servico>) pm.newQuery(query).execute();

        return lista_de_exames;

    }

    public static LinkedList<Servico> devolveExamesUtente(final Long id_utente) throws Exception {

        PersistenceManager pm = PMF.get().getPersistenceManager();
        //SELECT * FROM servicoprestado, servicogenerico WHERE
        // servicogenerico.id_servico_generico=servicoprestado.id_servico_generico
        //AND servicoprestado.id_utente='var_id_utente' AND servicogenerico.tipo='exame'
        String query = "select from " + Servico.class.getName()
                + " where id_utente == " + id_utente;
        List<Servico> lista1 = (List<Servico>) pm.newQuery(query).execute();

        LinkedList<Servico> lista_exames = new LinkedList<Servico>();

        for (Servico s : lista1) {
            if(ServicoGenerico.eTipoExame(s.getServicoGenerico()))
                lista_exames.add(s);
        }

        return lista_exames;
    }

    public static List<Servico> devolveTodosOsCancelados() throws ClassNotFoundException, InstantiationException,
            IllegalAccessException {


        PersistenceManager pm = PMF.get().getPersistenceManager();

        String query = "select from " + Servico.class.getName();

        List<Servico> lista_de_todos_cancelados = (List<Servico>) pm.newQuery(query).execute();

        return lista_de_todos_cancelados;


    }

    public static LinkedList<Servico> devolveTodosOsCanceladosDoUtente(final Long id_utente) throws Exception {

        //SELECT * FROM servicoprestado WHERE estado='cancelado' AND id_utente=var_id_utente ORDER BY data ASC
        PersistenceManager pm = PMF.get().getPersistenceManager();

        String query = "select from " + Servico.class.getName()
                + " where id_utente == " + id_utente + " && estado == 'cancelado'";

        List<Servico> lista_de_cancelados_utente = (List<Servico>) pm.newQuery(query).execute();

        LinkedList<Servico> cancelados_utente = new LinkedList<Servico>();
        for (Servico s : lista_de_cancelados_utente) {
            cancelados_utente.add(s);
        }

        return cancelados_utente;


    }

    public static List<Servico> devolveTodosOsCanceladosDoColaborador(final Long id_colaborador) throws ClassNotFoundException,
            InstantiationException, IllegalAccessException {



        PersistenceManager pm = PMF.get().getPersistenceManager();

        String query = "select from " + Servico.class.getName()
                + " where id_colaborador == " + id_colaborador;

        List<Servico> lista_de_cancelados_colaborador = (List<Servico>) pm.newQuery(query).execute();

        return lista_de_cancelados_colaborador;



    }

    public static List<Servico> devolveTodosOsConcluidos() throws ClassNotFoundException, InstantiationException,
            IllegalAccessException {

        PersistenceManager pm = PMF.get().getPersistenceManager();

        String query = "select from " + Servico.class.getName();

        List<Servico> lista_de_todos_concluido = (List<Servico>) pm.newQuery(query).execute();

        return lista_de_todos_concluido;



    }

    public static List devolveFichasParaLink(final Long id_pessoa) {//throws RuntimeException, ClassNotFoundException,
        // InstantiationException, IllegalAccessException {

        PersistenceManager pm = PMF.get().getPersistenceManager();

        String query = "select from " + Servico.class.getName()
                + " where id_pessoa == " + id_pessoa;

        List<Servico> lista_de_fichas_link = (List<Servico>) pm.newQuery(query).execute();

        return lista_de_fichas_link;

    }

    public static List devolveTodosOsDadosDaFichaMedica(final Long id_servico_prestado) throws ClassNotFoundException,
            InstantiationException, IllegalAccessException {

        PersistenceManager pm = PMF.get().getPersistenceManager();

        String query = "select from " + Servico.class.getName()
                + " where id_prestado == " + id_servico_prestado;

        List<Servico> lista_de_dados_ficha = (List<Servico>) pm.newQuery(query).execute();

        return lista_de_dados_ficha;


    }

    public static LinkedList<Servico> devolveTodosOsConcluidosDoUtente(final Long id_utente) throws Exception {

        PersistenceManager pm = PMF.get().getPersistenceManager();

        //SELECT * FROM servicoprestado WHERE (estado='concluido_por_falta'
        //|| estado='concluido_por_comparencia') AND id_utente=var_id_utente ORDER BY data ASC
        String query = "select from " + Servico.class.getName()
                + " where id_utente == " + id_utente + " && (estado == 'concluido_por_falta' || estado == 'concluido_por_comparencia')";

        List<Servico> lista_de_concluido_utente = (List<Servico>) pm.newQuery(query).execute();

        LinkedList<Servico> concluidos_utente = new LinkedList<Servico>();
        for (Servico s : lista_de_concluido_utente) {
            concluidos_utente.add(s);
        }

        return concluidos_utente;
    }

    public static List<Servico> devolveTodosOsConcluidosDoColaborador(final Long id_colaborador) throws ClassNotFoundException,
            InstantiationException, IllegalAccessException {

        PersistenceManager pm = PMF.get().getPersistenceManager();

        String query = "select from " + Servico.class.getName()
                + " where id_colaborador == " + id_colaborador;

        List<Servico> lista_de_concluido_colaborador = (List<Servico>) pm.newQuery(query).execute();

        return lista_de_concluido_colaborador;

    }

    public static List<Servico> devolveTodosDoPagamento(final Long id_pagamento) throws ClassNotFoundException,
            InstantiationException, IllegalAccessException {

        PersistenceManager pm = PMF.get().getPersistenceManager();

        String query = "select from " + Servico.class.getName()
                + " where id_pagamento == " + id_pagamento;

        List<Servico> lista_de_todos_pagamentos = (List<Servico>) pm.newQuery(query).execute();

        return lista_de_todos_pagamentos;

    }

    public static List<Servico> devolveTodosDoDia() throws ClassNotFoundException, InstantiationException, IllegalAccessException {

        PersistenceManager pm = PMF.get().getPersistenceManager();

        String query = "select from " + Servico.class.getName();

        List<Servico> lista_de_todos_dias = (List<Servico>) pm.newQuery(query).execute();

        return lista_de_todos_dias;
    }

    public static List<Servico> devolveTodosDoDiaDoColaborador(final Long id_colaborador) throws ClassNotFoundException,
            InstantiationException, IllegalAccessException {

        PersistenceManager pm = PMF.get().getPersistenceManager();

        String query = "select from " + Servico.class.getName()
                + " where id_colaborador == " + id_colaborador;

        List<Servico> lista_de_todos_dias_colaborador = (List<Servico>) pm.newQuery(query).execute();

        return lista_de_todos_dias_colaborador;
    }

    public boolean estaPago() {
        return id_pagamento > 0;
    }

    /*public void removePagamento() {
    this.id_pagamento = -1;
     * FALTA VER
    }*/
    public void paga(final Long id_pagamento) {
        this.id_pagamento = id_pagamento;
    }

    public boolean temFichaMedica() {
        return sintoma != null && diagnostico != null && observacao_publica != null && observacao_privada != null;
    }
}



